using Mbl.ParameterizedTest.FluentCollectionBuilding.Expectors.StringExpectations;

namespace Mbl.ParameterizedTest.FluentCollectionBuilding.Expectors
{
    public class StringExpector<TIn1, TCollector> : Expector<TIn1, string, TCollector>
        where TCollector : ITestCollector<TIn1, string>
    {
        public StringExpector(TCollector testRowCollector, TestCase<TIn1, string> testCase)
            : base(testRowCollector, testCase)
        {
            
        }

        public Justifier<TIn1, string, TCollector> ExpectContains(string expectedpart)
        {
            return CreateJustifier(new ContainsExpectation(expectedpart));
        }

		public Justifier<TIn1, string, TCollector> ExpectStartsWith(string expectedStart)
        {
            return CreateJustifier(new StartsWithExpectation(expectedStart));
        }

		public Justifier<TIn1, string, TCollector> ExpectEndsWith(string expectedEnd)
        {
            return CreateJustifier(new EndsWithExpectation(expectedEnd));
        }

		public Justifier<TIn1, string, TCollector> ExpectIgnoringCase(string expected)
        {
            return CreateJustifier(new EqualityIgnoringCaseExpectation(expected));
        }

		public Justifier<TIn1, string, TCollector> ExpectI(string expected)
        {
            return ExpectIgnoringCase(expected);
        }
    }    

    public class StringExpector<TIn1, TIn2, TCollector> : Expector<TIn1, TIn2, string, TCollector>
        where TCollector : ITestCollector<TIn1, TIn2, string>
    {
        public StringExpector(TCollector testRowCollector, TestCase<TIn1, TIn2, string> testCase)
            : base(testRowCollector, testCase)
        {
            
        }

        public Justifier<TIn1, TIn2, string, TCollector> ExpectContains(string expectedpart)
        {
            return CreateJustifier(new ContainsExpectation(expectedpart));
        }

		public Justifier<TIn1, TIn2, string, TCollector> ExpectStartsWith(string expectedStart)
        {
            return CreateJustifier(new StartsWithExpectation(expectedStart));
        }

		public Justifier<TIn1, TIn2, string, TCollector> ExpectEndsWith(string expectedEnd)
        {
            return CreateJustifier(new EndsWithExpectation(expectedEnd));
        }

		public Justifier<TIn1, TIn2, string, TCollector> ExpectIgnoringCase(string expected)
        {
            return CreateJustifier(new EqualityIgnoringCaseExpectation(expected));
        }

		public Justifier<TIn1, TIn2, string, TCollector> ExpectI(string expected)
        {
            return ExpectIgnoringCase(expected);
        }
    }    

    public class StringExpector<TIn1, TIn2, TIn3, TCollector> : Expector<TIn1, TIn2, TIn3, string, TCollector>
        where TCollector : ITestCollector<TIn1, TIn2, TIn3, string>
    {
        public StringExpector(TCollector testRowCollector, TestCase<TIn1, TIn2, TIn3, string> testCase)
            : base(testRowCollector, testCase)
        {
            
        }

        public Justifier<TIn1, TIn2, TIn3, string, TCollector> ExpectContains(string expectedpart)
        {
            return CreateJustifier(new ContainsExpectation(expectedpart));
        }

		public Justifier<TIn1, TIn2, TIn3, string, TCollector> ExpectStartsWith(string expectedStart)
        {
            return CreateJustifier(new StartsWithExpectation(expectedStart));
        }

		public Justifier<TIn1, TIn2, TIn3, string, TCollector> ExpectEndsWith(string expectedEnd)
        {
            return CreateJustifier(new EndsWithExpectation(expectedEnd));
        }

		public Justifier<TIn1, TIn2, TIn3, string, TCollector> ExpectIgnoringCase(string expected)
        {
            return CreateJustifier(new EqualityIgnoringCaseExpectation(expected));
        }

		public Justifier<TIn1, TIn2, TIn3, string, TCollector> ExpectI(string expected)
        {
            return ExpectIgnoringCase(expected);
        }
    }    

    public class StringExpector<TIn1, TIn2, TIn3, TIn4, TCollector> : Expector<TIn1, TIn2, TIn3, TIn4, string, TCollector>
        where TCollector : ITestCollector<TIn1, TIn2, TIn3, TIn4, string>
    {
        public StringExpector(TCollector testRowCollector, TestCase<TIn1, TIn2, TIn3, TIn4, string> testCase)
            : base(testRowCollector, testCase)
        {
            
        }

        public Justifier<TIn1, TIn2, TIn3, TIn4, string, TCollector> ExpectContains(string expectedpart)
        {
            return CreateJustifier(new ContainsExpectation(expectedpart));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, string, TCollector> ExpectStartsWith(string expectedStart)
        {
            return CreateJustifier(new StartsWithExpectation(expectedStart));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, string, TCollector> ExpectEndsWith(string expectedEnd)
        {
            return CreateJustifier(new EndsWithExpectation(expectedEnd));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, string, TCollector> ExpectIgnoringCase(string expected)
        {
            return CreateJustifier(new EqualityIgnoringCaseExpectation(expected));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, string, TCollector> ExpectI(string expected)
        {
            return ExpectIgnoringCase(expected);
        }
    }    

    public class StringExpector<TIn1, TIn2, TIn3, TIn4, TIn5, TCollector> : Expector<TIn1, TIn2, TIn3, TIn4, TIn5, string, TCollector>
        where TCollector : ITestCollector<TIn1, TIn2, TIn3, TIn4, TIn5, string>
    {
        public StringExpector(TCollector testRowCollector, TestCase<TIn1, TIn2, TIn3, TIn4, TIn5, string> testCase)
            : base(testRowCollector, testCase)
        {
            
        }

        public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, string, TCollector> ExpectContains(string expectedpart)
        {
            return CreateJustifier(new ContainsExpectation(expectedpart));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, string, TCollector> ExpectStartsWith(string expectedStart)
        {
            return CreateJustifier(new StartsWithExpectation(expectedStart));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, string, TCollector> ExpectEndsWith(string expectedEnd)
        {
            return CreateJustifier(new EndsWithExpectation(expectedEnd));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, string, TCollector> ExpectIgnoringCase(string expected)
        {
            return CreateJustifier(new EqualityIgnoringCaseExpectation(expected));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, string, TCollector> ExpectI(string expected)
        {
            return ExpectIgnoringCase(expected);
        }
    }    

    public class StringExpector<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TCollector> : Expector<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string, TCollector>
        where TCollector : ITestCollector<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string>
    {
        public StringExpector(TCollector testRowCollector, TestCase<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string> testCase)
            : base(testRowCollector, testCase)
        {
            
        }

        public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string, TCollector> ExpectContains(string expectedpart)
        {
            return CreateJustifier(new ContainsExpectation(expectedpart));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string, TCollector> ExpectStartsWith(string expectedStart)
        {
            return CreateJustifier(new StartsWithExpectation(expectedStart));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string, TCollector> ExpectEndsWith(string expectedEnd)
        {
            return CreateJustifier(new EndsWithExpectation(expectedEnd));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string, TCollector> ExpectIgnoringCase(string expected)
        {
            return CreateJustifier(new EqualityIgnoringCaseExpectation(expected));
        }

		public Justifier<TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, string, TCollector> ExpectI(string expected)
        {
            return ExpectIgnoringCase(expected);
        }
    }    

}